﻿//using System;
//using System.Collections.Generic;
//using System.Linq;
//using System.Text;
//using System.Threading.Tasks;

//namespace Tools.CacheHelper
//{
//    /// <summary>
//    /// 缓存
//    /// </summary>
//    public class MemoryCacherHelper
//    {
//        // 创建一个 MemoryCache 实例
//        private static readonly IMemoryCache _cache = new MemoryCache(new MemoryCacheOptions());

//        /// <summary>
//        /// 从缓存中获取数据。
//        /// </summary>
//        /// <typeparam name="T">要获取的数据的类型。</typeparam>
//        /// <param name="key">缓存键。</param>
//        /// <returns>如果缓存中存在对应键的数据，则返回该数据；否则返回 null。</returns>
//        public static T? Get<T>(string key) where T : class
//        {
//            if (string.IsNullOrWhiteSpace(key))
//                throw new ArgumentNullException(nameof(key));

//            return _cache.TryGetValue(key, out T? value) ? value : null;
//        }

//        /// <summary>
//        /// 从缓存中获取数据。
//        /// </summary>
//        /// <typeparam name="T">要获取的数据的类型。</typeparam>
//        /// <param name="key">缓存键。</param>
//        /// <returns>如果缓存中存在对应键的数据，则返回该数据；否则返回 null。</returns>
//        public static async Task<T?> GetAsync<T>(string key) where T : class
//        {
//            if (string.IsNullOrWhiteSpace(key))
//                throw new ArgumentNullException(nameof(key));
//            return await Task.Run(() => Get<T>(key)).ConfigureAwait(false);
//        }

//        /// <summary>
//        /// 将数据存储到缓存中。会永久有效请尽量指定过期时间
//        /// </summary>
//        /// <typeparam name="T">要存储的数据的类型。</typeparam>
//        /// <param name="key">缓存键。</param>
//        /// <param name="value">要存储的数据。</param>
//        //public static void Set<T>(string key, T value) where T : class
//        //{
//        //    if (string.IsNullOrWhiteSpace(key))
//        //        throw new ArgumentNullException(nameof(key));

//        //    _cache.Set(key, value);
//        //}

//        /// <summary>
//        /// 将数据存储到缓存中。会永久有效请尽量指定过期时间
//        /// </summary>
//        /// <typeparam name="T">要存储的数据的类型。</typeparam>
//        /// <param name="key">缓存键。</param>
//        /// <param name="value">要存储的数据。</param>
//        //public static async Task SetAsync<T>(string key, T value) where T : class
//        //{
//        //    if (string.IsNullOrWhiteSpace(key))
//        //        throw new ArgumentNullException(nameof(key));

//        //    await Task.Run(() => Set(key, value)).ConfigureAwait(false);
//        //}

//        /// <summary>
//        /// 将数据存储到缓存中。
//        /// </summary>
//        /// <typeparam name="T">要存储的数据的类型。</typeparam>
//        /// <param name="key">缓存键。</param>
//        /// <param name="value">要存储的数据。</param>
//        /// <param name="span">有效时间。</param>
//        public static void Set<T>(string key, T value, TimeSpan span) where T : class
//        {
//            if (string.IsNullOrWhiteSpace(key))
//                throw new ArgumentNullException(nameof(key));

//            _cache.Set(key, value, span);
//        }

//        /// <summary>
//        /// 将数据存储到缓存中。
//        /// </summary>
//        /// <typeparam name="T">要存储的数据的类型。</typeparam>
//        /// <param name="key">缓存键。</param>
//        /// <param name="value">要存储的数据。</param>
//        /// <param name="span">有效时间。</param>
//        public static async Task SetAsync<T>(string key, T value, TimeSpan span) where T : class
//        {
//            if (string.IsNullOrWhiteSpace(key))
//                throw new ArgumentNullException(nameof(key));

//            await Task.Run(() => Set(key, value, span)).ConfigureAwait(false);
//        }

//        /// <summary>
//        /// 将数据存储到缓存中，并指定缓存选项。
//        /// </summary>
//        /// <typeparam name="T">要存储的数据的类型。</typeparam>
//        /// <param name="key">缓存键。</param>
//        /// <param name="value">要存储的数据。</param>
//        /// <param name="options">缓存选项，如过期策略。</param>
//        public static void Set<T>(string key, T value, MemoryCacheEntryOptions options) where T : class
//        {
//            if (string.IsNullOrWhiteSpace(key))
//                throw new ArgumentNullException(nameof(key));

//            _cache.Set(key, value, options);
//        }

//        /// <summary>
//        /// 将数据存储到缓存中，并指定缓存选项。
//        /// </summary>
//        /// <typeparam name="T">要存储的数据的类型。</typeparam>
//        /// <param name="key">缓存键。</param>
//        /// <param name="value">要存储的数据。</param>
//        /// <param name="options">缓存选项，如过期策略。</param>
//        public static async Task SetAsync<T>(string key, T value, MemoryCacheEntryOptions options) where T : class
//        {
//            if (string.IsNullOrWhiteSpace(key))
//                throw new ArgumentNullException(nameof(key));

//            await Task.Run(() => Set(key, value, options)).ConfigureAwait(false);
//        }

//        /// <summary>
//        /// 从缓存中移除指定键的数据。
//        /// </summary>
//        /// <param name="key">要移除的缓存键。</param>
//        public static void Remove(string key)
//        {
//            if (string.IsNullOrWhiteSpace(key))
//                throw new ArgumentNullException(nameof(key));
//            _cache.Remove(key);
//        }

//        /// <summary>
//        /// 从缓存中移除指定键的数据。
//        /// </summary>
//        /// <param name="key">要移除的缓存键。</param>
//        public static async Task RemoveAsync(string key)
//        {
//            if (string.IsNullOrWhiteSpace(key))
//                throw new ArgumentNullException(nameof(key));

//            await Task.Run(() => Remove(key)).ConfigureAwait(false);
//        }

//        /// <summary>
//        /// 释放缓存对象。
//        /// </summary>
//        public static void Dispose()
//        {
//            _cache.Dispose();
//        }

//        /// <summary>
//        /// 释放缓存对象。
//        /// </summary>
//        public static async Task DisposeAsync()
//        {
//            await Task.Run(() => Dispose()).ConfigureAwait(false);
//        }
//    }
//}